By

文章目录
  1. 1. clone() 元定义
  2. 2. clone不伤害源对象
  3. 3. 数组的clone
  4. 4. 使用循环代替递归拷贝
  5. 5. 可以考虑使用拷贝构造器来代码clone方法
  6. 6. 总结
  7. 7. 参考






clone() 元定义

啥都不说，先看下源码中Object.clone()的定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
/**
 * Creates and returns a copy of this object.  The precise meaning
 * of "copy" may depend on the class of the object. The general
 * intent is that, for any object {@code x}, the expression:
 * <blockquote>
 * <pre>
 * x.clone() != x</pre></blockquote>
 * will be true, and that the expression:
 * <blockquote>
 * <pre>
 * x.clone().getClass() == x.getClass()</pre></blockquote>
 * will be {@code true}, but these are not absolute requirements.
 * While it is typically the case that:
 * <blockquote>
 * <pre>
 * x.clone().equals(x)</pre></blockquote>
 * will be {@code true}, this is not an absolute requirement.
 * <p>
 * By convention, the returned object should be obtained by calling
 * {@code super.clone}.  If a class and all of its superclasses (except
 * {@code Object}) obey this convention, it will be the case that
 * {@code x.clone().getClass() == x.getClass()}.
 * 创建和返回对象的拷贝需要满足
 * x.clone()!=x （拷贝返回的东西不能用原来的地址啊~^_^）
 * x.clone().getClass==x.getClass() （这个不是绝对的，可以返回子类）
 * x.clone().equals(x) （拷贝了之后当然两个对象时相等的~，这个也不是绝对的，比如有序    	列化唯一ID的字段）
 * 
 * <p>
 * By convention, the object returned by this method should be independent
 * of this object (which is being cloned).  To achieve this independence,
 * it may be necessary to modify one or more fields of the object returned
 * by {@code super.clone} before returning it.  Typically, this means
 * copying any mutable objects that comprise the internal "deep structure"
 * of the object being cloned and replacing the references to these
 * objects with references to the copies.  If a class contains only
 * primitive fields or references to immutable objects, then it is usually
 * the case that no fields in the object returned by {@code super.clone}
 * need to be modified.
 * 教我们实现clone方法的时候先调用super.clone(),克隆出的对象上添加自己当前类所需要的元素
 * <p>
 * The method {@code clone} for class {@code Object} performs a
 * specific cloning operation. First, if the class of this object does
 * not implement the interface {@code Cloneable}, then a
 * {@code CloneNotSupportedException} is thrown. Note that all arrays
 * are considered to implement the interface {@code Cloneable} and that
 * the return type of the {@code clone} method of an array type {@code T[]}
 * is {@code T[]} where T is any reference or primitive type.
 * Otherwise, this method creates a new instance of the class of this
 * object and initializes all its fields with exactly the contents of
 * the corresponding fields of this object, as if by assignment; the
 * contents of the fields are not themselves cloned. Thus, this method
 * performs a "shallow copy" of this object, not a "deep copy" operation.
 * 如果对象没有实现Cloneable接口而又调用了super.clone  就是抛出CloneNotSupportedException异常
 * 默认所有的数组都是继承了Cloneable接口的，它返回的是该数组类型的数组(T[] -_-)，但是 *拷贝的时候直接是使用了那么些类型的对象，并没有使用它们的拷贝，所以数据的拷贝只是一
 * 个“浅拷贝”
 * <p>
 * The class {@code Object} does not itself implement the interface
 * {@code Cloneable}, so calling the {@code clone} method on an object
 * whose class is {@code Object} will result in throwing an
 * exception at run time.
 * Object类并没有实现Cloneable接口，所以你如果调用了Oject.clone方法话就会抛出异常，
 * （但是在在这里可以看到Object的clone方法是protected的，该方法是无法直接调用的，除非
 * 你使用反射来进行调用）
 *
 * @return     a clone of this instance.
 * @exception  CloneNotSupportedException  if the object's class does not
 *               support the {@code Cloneable} interface. Subclasses
 *               that override the {@code clone} method can also
 *               throw this exception to indicate that an instance cannot
 *               be cloned.
 * @see java.lang.Cloneable
 */
protected native Object clone() throws CloneNotSupportedException;

Cloneable接口并不含任何方法，但是实现它的时候Object的clone方法就会返回该对象的逐域拷贝，否则就会抛出CloneNotSupportedException异常

注意，在java1.5以后的版本中clone()引入了协变返回类型，额可以直接直接支持指定类的返回，不必必须返回Object

clone不伤害源对象

clone()的原则就是必须确保不会伤害到原始的对象，并确保正确地创建被克隆中的约束条件。
实现克隆最基本的方法是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class CloneTest implements Cloneable{
	public int[] elements=new int[10];
	
	/**
	 * 进行数组的打印
	 */
	public void print()
	{
		System.out.println("\r\nprint");
		for(int i=0;i<this.elements.length;i++)
		{
			System.out.print(elements[i]+"#");
		}
	}
	
	@Override
	public CloneTest clone()
	{
		CloneTest ret=null;
		try
		{
			ret=(CloneTest)super.clone();//调用超类的clone
		}catch(CloneNotSupportedException cs)
		{
			cs.printStackTrace();
		}
		
		return ret;
		
	}
}

但是他会破坏原有对象：

1
2
3
4
5
6
7
8
9
CloneTest t1=new CloneTest();
t1.elements[0]=4;
t1.elements[1]=5;

CloneTest t2=t1.clone();
t2.elements[1]=6;

t1.print();
t2.print();

返回的是：

print
4#6#0#0#0#0#0#0#0#0#
print
4#6#0#0#0#0#0#0#0#0#

这是因为该方法仅仅只是调用了超类的克隆方法，完了之后克隆出来的对象的elements元素还是与原对象一样。

所以一般在编写clone()之后，再在克隆出的对象上添加自己当前类所需要的元素，上述可以这么修改:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Override
public CloneTest clone()
{
	CloneTest ret=null;
	try
	{
		ret=(CloneTest)super.clone();
		ret.elements=this.elements.clone();//复制出来一个新的副本
	}catch(CloneNotSupportedException cs)
	{
		cs.printStackTrace();
	}
	
	return ret;
	
}

在先前的测试代码之后得到的是

print
4#5#0#0#0#0#0#0#0#0#
print
4#6#0#0#0#0#0#0#0#0#

简而言之，所有实现了Cloneable的类都应该调用一个共有的方法覆盖clone，此公有的方法首先调用super.clone()，然后修正任何需要修正的域（其实就是对当前自己类上的元素单独clone()）。

数组的clone

引用的一个类

1
2
3
4
5
6
7
static class A{
	public String name="";
	
	public A(String name){
		this.name=name;
	}
}

对数组进行clone()

1
2
3
4
5
6
7
8
A[] a=new A[2];
a[0]=new A("tom");
a[0]=new A("peter");

A[] b=a.clone();
b[0].name="lili";、//修改克隆对象的值

System.out.println(a[0].name);

最终的输出为

lili

可以发现原有数组A的数据被他克隆出来的数组给修掉了，所以数组在执行clone()时并没有将数据类型的对象进行克隆，只是使用了它，这里也就是一个浅复制。（对于这种情况我们特别要注意~）

使用循环代替递归拷贝

在HashTable中是使用一个列表数组来存储具体数据，在对HashTable进行拷贝时他的源码是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * Creates a shallow copy of this hashtable. All the structure of the
 * hashtable itself is copied, but the keys and values are not cloned.
 * This is a relatively expensive operation.
 *
 * @return  a clone of the hashtable
 */
public synchronized Object clone() {
    try {
        Hashtable<K,V> t = (Hashtable<K,V>) super.clone();
        t.table = new Entry[table.length];
        for (int i = table.length ; i-- > 0 ; ) {
            t.table[i] = (table[i] != null)
                ? (Entry<K,V>) table[i].clone() : null;//这里调用Entry的clone方法
        }
        t.keySet = null;
        t.entrySet = null;
        t.values = null;
        t.modCount = 0;
        return t;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError();
    }
}

接下来看下Entry.clone()方法：

1
2
3
4
protected Object clone() {
    return new Entry<>(hash, key, value,
                          (next==null ? null : (Entry<K,V>) next.clone()));
}

从它的方法中我们可以看出来他是使用递归来进行调用的，不断进行递归执行自己的clone时自己的链表增长来满足clone，这可以说是一种比较简洁的方法，但是问题是出在递归，我们都知道执行递归方法时如果递归太深可能会触发虚拟机中最大stack数量的阈值导致抛StackOverflow的异常，并且执行一个方法本身也是一个比较耗资源的的操作，所以如果遇到这种情况可以考虑使用循环来完成这种需求。

1
2
3
4
5
6
7
8
9
10
//使用循环来代替递归
protected Object clone() {
	Entry result=new Entry(key,value,next);
	for(Entry p=result;p.next!=null;p=p.next)
	{
		p.next=new Entry(p.next.key,p.next.value,p.next.next);
	}
	
	return result;
}

针对此我们可以看下jdk1.2之后出来的HashMap里面的clone方法，他在super.clone()完了之后调用inflateTable()方法重新初始化了一个数组，然后再调用putAllForCreate()方法用循环的方式将现有数据进行添加进去完成clone()

可以考虑使用拷贝构造器来代码clone方法

该功能的类的拷贝构造器相比clone()方法来说有以下几个好处：

  • 在该构造器可以有参数
  • 支持final类型定义的变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class CloneTest{
	    public int[] elements=new int[10];

	    /**
	     * 进行数组的打印
	     */
	    public void print()
	    {
	        System.out.println("\r\nprint");
	        for(int i=0;i<this.elements.length;i++)
	        {
	            System.out.print(elements[i]+"#");
	        }
	    }
	    
	    public CloneTest()
	    {}
	    
	    public CloneTest(CloneTest test){
	    	CloneTest ret=test;
	    	ret.elements=test.elements.clone();
	    }
	}

这样的话就可以使用构造函数来进行对象的：

1
2
3
4
5
6
7
8
9
CloneTest t1=new CloneTest();
t1.elements[0]=4;
t1.elements[1]=5;

CloneTest t2=new CloneTest(t1);
t2.elements[1]=6;

t1.print();
t2.print();

总结

最后，关于clone()方法有以下几个注意点：

  • 将出现递归clone()的时候尽量使用循环迭代来代替。
  • 如果是线程安全的类要实现clone()，那些这个clone()也必须进行同步。
  • 关于自身域的修正如果是遇到final类型的，那么这两者是不兼容的。
  • 另一个实现对象拷贝的方式就是提供一个拷贝构造器，该构造器比clone()方法的一个优势就是它可以传参数。
  • 当前类没有继承Cloneable接口时，如果到clone()方法里面调用了super.clone()方法就是抛出CloneNotSupportedException异常。

参考

《Effective Java中文版》第11条

本作品采用[知识共享署名-非商业性使用-相同方式共享 2.5]中国大陆许可协议进行许可，我的博客欢迎复制共享，但在同时，希望保留我的署名权kubiCode，并且，不得用于商业用途。如您有任何疑问或者授权方面的协商，请给我留言。

文章目录
  1. 1. clone() 元定义
  2. 2. clone不伤害源对象
  3. 3. 数组的clone
  4. 4. 使用循环代替递归拷贝
  5. 5. 可以考虑使用拷贝构造器来代码clone方法
  6. 6. 总结
  7. 7. 参考